package n92_任务调度线程池;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

import static utils.Sleeper.sleep;

/**
 * @author fu
 * @date 2022-04-05 13:33
 * 概要：
 * ---------------------------------------------------------------
 * |                                                             |
 * |             ------   处理异常的几种方法   ------              |
 * |                                                            |
 * |=============================================================
 */
@Slf4j(topic = "c.T4")
public class T3_处理异常_两种方法 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        _test1_try_catch_处理任务调度线程池();
//        _test2_try_catch_处理普通线程池();
        _test3_future返回值_处理普通线程池();

    }

     /**
     * Executors工具的 调度功能线程池 处理异常  [try-catch]
     */
    private static void _test1_try_catch_处理任务调度线程池() {
        // 带有 调度功能的 线程池
        final ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);

        log.debug("begin......");

        pool.schedule(()->{
            log.debug("task1");
            sleep(2);

            int i = 0;
            try {
                i = 1/0;
            } catch (Exception e) {
//                exception.printStackTrace();
                log.error("error:",e);
            }

            log.debug("task1--结束 结果={}",i);
        }, 1, TimeUnit.SECONDS);
    }
     /**
     * Executors工具的 普通线程池 处理异常     [try-catch]
     */
     private static void _test2_try_catch_处理普通线程池() {
        final ExecutorService pool = Executors.newFixedThreadPool(1);

        pool.submit(()->{
            log.debug("task1");
            sleep(2);

            int i = 0;
            try {
                i = 1/0;
            } catch (Exception e) {
//                exception.printStackTrace();
                log.error("error:",e);
            }

            log.debug("task1--结束 结果={}",i);
        });
    }
     /**
     * Executors工具的 普通线程池 处理异常     [futrue]
     */
     private static void _test3_future返回值_处理普通线程池() throws ExecutionException, InterruptedException {
        final ExecutorService pool = Executors.newFixedThreadPool(1);

        // future 接收
        final Future<Integer> future = pool.submit(() -> {
            log.debug("task1");
            sleep(2);

            int i = 0;
            i = 1 / 0;

            log.debug("task1--结束 结果={}", i);
            return i;
        });

         /*
          * 获取结果打印，【get() 获取结果 过程中报异常】
          */
         Integer integer=0;
         try {
             integer = future.get();
         } catch (InterruptedException | ExecutionException e) {
             e.printStackTrace();
         }
         log.debug("result:{}", integer);
     }



}
